package main

import "fmt"

/*
(函数要先定义,在调用)
func funcName(type1,type2)(output1,output2){
//逻辑代码
//返回值
return value1,value2
}
*/

func getSum(n int) int {
	sum := 0

	for i := 0; i < n; i++ {
		sum += i

	}
	return sum
}

// 定义结构体A
type A struct {
	value int
}

// 指针传递
func DoSomethingPointer(a *A) {
	b := a
	b.value = 100
	fmt.Println(b.value)
}

// 值传递
func DoSomethingValue(a A) {
	b := &a
	b.value = 100
	fmt.Println(b.value)
}

// defer函数

func P(string2 string) {
	fmt.Println(string2)
}
func main() {

	//fmt.Println(getSum(5))
	// 创建一个结构体实例
	original := A{value: 10}

	// 使用指针传递（map,slice,channel）
	fmt.Println("指针传递前value:", original.value)
	DoSomethingPointer(&original)
	fmt.Println("指针传递后value:", original.value)

	// 使用值传递
	original.value = 10 // 重置值
	fmt.Println("值传递value:", original.value)
	DoSomethingValue(original)
	fmt.Println("值传递后value:", original.value)
	//defer中延迟的函数是以栈的方式存在
	fmt.Println("hello")
	defer P("1")
	fmt.Println("world")
	defer P("2")
	//匿名函数，通常只能调用一次
	fun3 := func() {
		fmt.Println("匿名函数")
	}
	fun3()

	func() {
		fmt.Println("匿名函数2")
	}()
	//计算1-100万的和的匿名函数
	func() {
		sum := 0
		for i := 1; i <= 1e6; i++ {
			sum += i
		}
		fmt.Println(sum)
	}()

	x := min(1, 3, 2, 0)
	fmt.Printf("%d\n", x)
	slice := []int{7, 9, 3, 5, 1}
	x = min(slice...)
	fmt.Printf(" %d\n", x)
}
func min(s ...int) int {
	if len(s) == 0 {
		return 0
	}
	min := s[0]
	for _, v := range s {
		if v < min {
			min = v
		}
	}
	return min
}
